package ${projectConfig.beanPackage}.${config.model}.bean.po.gen;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.List;

public class ${config.objectName}Example {
    protected String orderByClause;

    protected boolean distinct;

    protected List
<Criteria> oredCriteria;

    protected int limitStart = -1;

    protected int limitOffset = -1;

    public ${config.objectName}Example() {
    oredCriteria = new ArrayList
    <Criteria>();
        }

        public void setOrderByClause(String orderByClause) {
        this.orderByClause = orderByClause;
        }

        public String getOrderByClause() {
        return orderByClause;
        }

        public void setDistinct(boolean distinct) {
        this.distinct = distinct;
        }

        public boolean isDistinct() {
        return distinct;
        }

        public List
        <Criteria> getOredCriteria() {
            return oredCriteria;
            }

            public void or(Criteria criteria) {
            oredCriteria.add(criteria);
            }

            public Criteria or() {
            Criteria criteria = createCriteriaInternal();
            oredCriteria.add(criteria);
            return criteria;
            }

            public Criteria createCriteria() {
            Criteria criteria = createCriteriaInternal();
            if (oredCriteria.size() == 0) {
            oredCriteria.add(criteria);
            }
            return criteria;
            }

            protected Criteria createCriteriaInternal() {
            Criteria criteria = new Criteria();
            return criteria;
            }

            public void clear() {
            oredCriteria.clear();
            orderByClause = null;
            distinct = false;
            }

            public void setLimitStart(int limitStart) {
            this.limitStart=limitStart;
            }

            public int getLimitStart() {
            return limitStart;
            }

            public void setLimitOffset(int limitOffset) {
            this.limitOffset=limitOffset;
            }

            public int getLimitOffset() {
            return limitOffset;
            }

            protected abstract static class GeneratedCriteria {
            protected List
            <Criterion> criteria;

                protected GeneratedCriteria() {
                super();
                criteria = new ArrayList
                <Criterion>();
                    }

                    public boolean isValid() {
                    return criteria.size() > 0;
                    }

                    public List
                    <Criterion> getAllCriteria() {
                        return criteria;
                        }

                        public List
                        <Criterion> getCriteria() {
                            return criteria;
                            }

                            protected void addCriterion(String condition) {
                            if (condition == null) {
                            throw new RuntimeException("Value for condition cannot be null");
                            }
                            criteria.add(new Criterion(condition));
                            }

                            protected void addCriterion(String condition, Object value, String property) {
                            if (value == null) {
                            throw new RuntimeException("Value for " + property + " cannot be null");
                            }
                            criteria.add(new Criterion(condition, value));
                            }

                            protected void addCriterion(String condition, Object value1, Object value2, String property)
                            {
                            if (value1 == null || value2 == null) {
                            throw new RuntimeException("Between values for " + property + " cannot be null");
                            }
                            criteria.add(new Criterion(condition, value1, value2));
                            }

                            protected void addCriterionForJDBCDate(String condition, Date value, String property) {
                            if (value == null) {
                            throw new RuntimeException("Value for " + property + " cannot be null");
                            }
                            addCriterion(condition, new java.sql.Date(value.getTime()), property);
                            }

                            protected void addCriterionForJDBCDate(String condition, List
                            <Date> values, String property) {
                                if (values == null || values.size() == 0) {
                                throw new RuntimeException("Value list for " + property + " cannot be null or empty");
                                }
                                List
                                <java.sql.Date> dateList = new ArrayList
                                    <java.sql.Date>();
                                        Iterator
                                        <Date> iter = values.iterator();
                                            while (iter.hasNext()) {
                                            dateList.add(new java.sql.Date(iter.next().getTime()));
                                            }
                                            addCriterion(condition, dateList, property);
                                            }

                                            protected void addCriterionForJDBCDate(String condition, Date value1, Date
                                            value2, String property) {
                                            if (value1 == null || value2 == null) {
                                            throw new RuntimeException("Between values for " + property + " cannot be
                                            null");
                                            }
                                            addCriterion(condition, new java.sql.Date(value1.getTime()), new
                                            java.sql.Date(value2.getTime()), property);
                                            }



<#list allcolumns as prop>
    <#if prop.javaType == "String">
        public Criteria and${prop.alias?cap_first}IsNull() {
            addCriterion("${prop.name} is null");
            return (Criteria) this;
        }

        public Criteria and${prop.alias?cap_first}IsNotNull() {
            addCriterion("${prop.name} is not null");
            return (Criteria) this;
        }

        public Criteria and${prop.alias?cap_first}EqualTo(String value) {
            addCriterion("${prop.name} =", value, "${prop.alias?cap_first}");
            return (Criteria) this;
        }

        public Criteria and${prop.alias?cap_first}NotEqualTo(String value) {
            addCriterion("${prop.name} <>", value, "${prop.alias?cap_first}");
            return (Criteria) this;
        }

        public Criteria and${prop.alias?cap_first}GreaterThan(String value) {
            addCriterion("${prop.name} >", value, "${prop.alias?cap_first}");
            return (Criteria) this;
        }

        public Criteria and${prop.alias?cap_first}GreaterThanOrEqualTo(String value) {
            addCriterion("${prop.name} >=", value, "${prop.alias?cap_first}");
            return (Criteria) this;
        }

        public Criteria and${prop.alias?cap_first}LessThan(String value) {
            addCriterion("${prop.name} <", value, "${prop.alias?cap_first}");
            return (Criteria) this;
        }

        public Criteria and${prop.alias?cap_first}LessThanOrEqualTo(String value) {
            addCriterion("${prop.name} <=", value, "${prop.alias?cap_first}");
            return (Criteria) this;
        }

        public Criteria and${prop.alias?cap_first}Like(String value) {
            addCriterion("${prop.name} like", value, "${prop.alias?cap_first}");
            return (Criteria) this;
        }

        public Criteria and${prop.alias?cap_first}NotLike(String value) {
            addCriterion("${prop.name} not like", value, "${prop.alias?cap_first}");
            return (Criteria) this;
        }

        public Criteria and${prop.alias?cap_first}In(List
    <String> values) {
            addCriterion("${prop.name} in", values, "${prop.alias?cap_first}");
            return (Criteria) this;
        }

        public Criteria and${prop.alias?cap_first}NotIn(List
    <String> values) {
            addCriterion("${prop.name} not in", values, "${prop.alias?cap_first}");
            return (Criteria) this;
        }

        public Criteria and${prop.alias?cap_first}Between(String value1, String value2) {
            addCriterion("${prop.name} between", value1, value2, "${prop.alias?cap_first}");
            return (Criteria) this;
        }

        public Criteria and${prop.alias?cap_first}NotBetween(String value1, String value2) {
            addCriterion("${prop.name} not between", value1, value2, "${prop.alias?cap_first}");
            return (Criteria) this;
        }
    <#elseif prop.javaType == "Integer">
        public Criteria and${prop.alias?cap_first}IsNull() {
            addCriterion("${prop.name} is null");
            return (Criteria) this;
        }

        public Criteria and${prop.alias?cap_first}IsNotNull() {
            addCriterion("${prop.name} is not null");
            return (Criteria) this;
        }

        public Criteria and${prop.alias?cap_first}EqualTo(Integer value) {
            addCriterion("${prop.name} =", value, "${prop.alias?cap_first}");
            return (Criteria) this;
        }

        public Criteria and${prop.alias?cap_first}NotEqualTo(Integer value) {
            addCriterion("${prop.name} <>", value, "${prop.alias?cap_first}");
            return (Criteria) this;
        }

        public Criteria and${prop.alias?cap_first}GreaterThan(Integer value) {
            addCriterion("${prop.name} >", value, "${prop.alias?cap_first}");
            return (Criteria) this;
        }

        public Criteria and${prop.alias?cap_first}GreaterThanOrEqualTo(Integer value) {
            addCriterion("${prop.name} >=", value, "${prop.alias?cap_first}");
            return (Criteria) this;
        }

        public Criteria and${prop.alias?cap_first}LessThan(Integer value) {
            addCriterion("${prop.name} <", value, "${prop.alias?cap_first}");
            return (Criteria) this;
        }

        public Criteria and${prop.alias?cap_first}LessThanOrEqualTo(Integer value) {
            addCriterion("${prop.name} <=", value, "${prop.alias?cap_first}");
            return (Criteria) this;
        }

        public Criteria and${prop.alias?cap_first}In(List
    <Integer> values) {
            addCriterion("${prop.name} in", values, "${prop.alias?cap_first}");
            return (Criteria) this;
        }

        public Criteria and${prop.alias?cap_first}NotIn(List
    <Integer> values) {
            addCriterion("${prop.name} not in", values, "${prop.alias?cap_first}");
            return (Criteria) this;
        }

        public Criteria and${prop.alias?cap_first}Between(Integer value1, Integer value2) {
            addCriterion("${prop.name} between", value1, value2, "${prop.alias?cap_first}");
            return (Criteria) this;
        }

        public Criteria and${prop.alias?cap_first}NotBetween(Integer value1, Integer value2) {
            addCriterion("${prop.name} not between", value1, value2, "${prop.alias?cap_first}");
            return (Criteria) this;
        }
    <#elseif prop.javaType == "Long">
        public Criteria and${prop.alias?cap_first}IsNull() {
            addCriterion("${prop.name} is null");
            return (Criteria) this;
        }

        public Criteria and${prop.alias?cap_first}IsNotNull() {
            addCriterion("${prop.name} is not null");
            return (Criteria) this;
        }

        public Criteria and${prop.alias?cap_first}EqualTo(Long value) {
            addCriterion("${prop.name} =", value, "${prop.alias?cap_first}");
            return (Criteria) this;
        }

        public Criteria and${prop.alias?cap_first}NotEqualTo(Long value) {
            addCriterion("${prop.name} <>", value, "${prop.alias?cap_first}");
            return (Criteria) this;
        }

        public Criteria and${prop.alias?cap_first}GreaterThan(Long value) {
            addCriterion("${prop.name} >", value, "${prop.alias?cap_first}");
            return (Criteria) this;
        }

        public Criteria and${prop.alias?cap_first}GreaterThanOrEqualTo(Long value) {
            addCriterion("${prop.name} >=", value, "${prop.alias?cap_first}");
            return (Criteria) this;
        }

        public Criteria and${prop.alias?cap_first}LessThan(Long value) {
            addCriterion("${prop.name} <", value, "${prop.alias?cap_first}");
            return (Criteria) this;
        }

        public Criteria and${prop.alias?cap_first}LessThanOrEqualTo(Long value) {
            addCriterion("${prop.name} <=", value, "${prop.alias?cap_first}");
            return (Criteria) this;
        }

        public Criteria and${prop.alias?cap_first}In(List
    <Long> values) {
            addCriterion("${prop.name} in", values, "${prop.alias?cap_first}");
            return (Criteria) this;
        }

        public Criteria and${prop.alias?cap_first}NotIn(List
    <Long> values) {
            addCriterion("${prop.name} not in", values, "${prop.alias?cap_first}");
            return (Criteria) this;
        }

        public Criteria and${prop.alias?cap_first}Between(Long value1, Long value2) {
            addCriterion("${prop.name} between", value1, value2, "${prop.alias?cap_first}");
            return (Criteria) this;
        }

        public Criteria and${prop.alias?cap_first}NotBetween(Long value1, Long value2) {
            addCriterion("${prop.name} not between", value1, value2, "${prop.alias?cap_first}");
            return (Criteria) this;
        }
    <#elseif prop.javaType == "BigDecimal">
        public Criteria and${prop.alias?cap_first}IsNull() {
            addCriterion("${prop.name} is null");
            return (Criteria) this;
        }

        public Criteria and${prop.alias?cap_first}IsNotNull() {
            addCriterion("${prop.name} is not null");
            return (Criteria) this;
        }

        public Criteria and${prop.alias?cap_first}EqualTo(BigDecimal value) {
            addCriterion("${prop.name} =", value, "${prop.alias?cap_first}");
            return (Criteria) this;
        }

        public Criteria and${prop.alias?cap_first}NotEqualTo(BigDecimal value) {
            addCriterion("${prop.name} <>", value, "${prop.alias?cap_first}");
            return (Criteria) this;
        }

        public Criteria and${prop.alias?cap_first}GreaterThan(BigDecimal value) {
            addCriterion("${prop.name} >", value, "${prop.alias?cap_first}");
            return (Criteria) this;
        }

        public Criteria and${prop.alias?cap_first}GreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("${prop.name} >=", value, "${prop.alias?cap_first}");
            return (Criteria) this;
        }

        public Criteria and${prop.alias?cap_first}LessThan(BigDecimal value) {
            addCriterion("${prop.name} <", value, "${prop.alias?cap_first}");
            return (Criteria) this;
        }

        public Criteria and${prop.alias?cap_first}LessThanOrEqualTo(BigDecimal value) {
            addCriterion("${prop.name} <=", value, "${prop.alias?cap_first}");
            return (Criteria) this;
        }

        public Criteria and${prop.alias?cap_first}In(List
    <BigDecimal> values) {
            addCriterion("${prop.name} in", values, "${prop.alias?cap_first}");
            return (Criteria) this;
        }

        public Criteria and${prop.alias?cap_first}NotIn(List
    <BigDecimal> values) {
            addCriterion("${prop.name} not in", values, "${prop.alias?cap_first}");
            return (Criteria) this;
        }

        public Criteria and${prop.alias?cap_first}Between(BigDecimal value1, BigDecimal value2) {
            addCriterion("${prop.name} between", value1, value2, "${prop.alias?cap_first}");
            return (Criteria) this;
        }

        public Criteria and${prop.alias?cap_first}NotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("${prop.name} not between", value1, value2, "${prop.alias?cap_first}");
            return (Criteria) this;
        }
    <#elseif prop.javaType == "Date">
        public Criteria and${prop.alias?cap_first}IsNull() {
            addCriterion("${prop.name} is null");
            return (Criteria) this;
        }

        public Criteria and${prop.alias?cap_first}IsNotNull() {
            addCriterion("${prop.name} is not null");
            return (Criteria) this;
        }

        public Criteria and${prop.alias?cap_first}EqualTo(Date value) {
            addCriterion("${prop.name} =", value, "${prop.alias?cap_first}");
            return (Criteria) this;
        }

        public Criteria and${prop.alias?cap_first}NotEqualTo(Date value) {
            addCriterion("${prop.name} <>", value, "${prop.alias?cap_first}");
            return (Criteria) this;
        }

        public Criteria and${prop.alias?cap_first}GreaterThan(Date value) {
            addCriterion("${prop.name} >", value, "${prop.alias?cap_first}");
            return (Criteria) this;
        }

        public Criteria and${prop.alias?cap_first}GreaterThanOrEqualTo(Date value) {
            addCriterion("${prop.name} >=", value, "${prop.alias?cap_first}");
            return (Criteria) this;
        }

        public Criteria and${prop.alias?cap_first}LessThan(Date value) {
            addCriterion("${prop.name} <", value, "${prop.alias?cap_first}");
            return (Criteria) this;
        }

        public Criteria and${prop.alias?cap_first}LessThanOrEqualTo(Date value) {
            addCriterion("${prop.name} <=", value, "${prop.alias?cap_first}");
            return (Criteria) this;
        }

        public Criteria and${prop.alias?cap_first}In(List
    <Date> values) {
            addCriterion("${prop.name} in", values, "${prop.alias?cap_first}");
            return (Criteria) this;
        }

        public Criteria and${prop.alias?cap_first}NotIn(List
    <Date> values) {
            addCriterion("${prop.name} not in", values, "${prop.alias?cap_first}");
            return (Criteria) this;
        }

        public Criteria and${prop.alias?cap_first}Between(Date value1, Date value2) {
            addCriterion("${prop.name} between", value1, value2, "${prop.alias?cap_first}");
            return (Criteria) this;
        }

        public Criteria and${prop.alias?cap_first}NotBetween(Date value1, Date value2) {
            addCriterion("${prop.name} not between", value1, value2, "${prop.alias?cap_first}");
            return (Criteria) this;
        }
    </#if>
</#list>
                                            }

                                            public static class Criteria extends GeneratedCriteria {

                                            protected Criteria() {
                                            super();
                                            }
                                            }

                                            public static class Criterion {
                                            private String condition;

                                            private Object value;

                                            private Object secondValue;

                                            private boolean noValue;

                                            private boolean singleValue;

                                            private boolean betweenValue;

                                            private boolean listValue;

                                            private String typeHandler;

                                            public String getCondition() {
                                            return condition;
                                            }

                                            public Object getValue() {
                                            return value;
                                            }

                                            public Object getSecondValue() {
                                            return secondValue;
                                            }

                                            public boolean isNoValue() {
                                            return noValue;
                                            }

                                            public boolean isSingleValue() {
                                            return singleValue;
                                            }

                                            public boolean isBetweenValue() {
                                            return betweenValue;
                                            }

                                            public boolean isListValue() {
                                            return listValue;
                                            }

                                            public String getTypeHandler() {
                                            return typeHandler;
                                            }

                                            protected Criterion(String condition) {
                                            super();
                                            this.condition = condition;
                                            this.typeHandler = null;
                                            this.noValue = true;
                                            }

                                            protected Criterion(String condition, Object value, String typeHandler) {
                                            super();
                                            this.condition = condition;
                                            this.value = value;
                                            this.typeHandler = typeHandler;
                                            if (value instanceof List<?>) {
                                            this.listValue = true;
                                            } else {
                                            this.singleValue = true;
                                            }
                                            }

                                            protected Criterion(String condition, Object value) {
                                            this(condition, value, null);
                                            }

                                            protected Criterion(String condition, Object value, Object secondValue,
                                            String typeHandler) {
                                            super();
                                            this.condition = condition;
                                            this.value = value;
                                            this.secondValue = secondValue;
                                            this.typeHandler = typeHandler;
                                            this.betweenValue = true;
                                            }

                                            protected Criterion(String condition, Object value, Object secondValue) {
                                            this(condition, value, secondValue, null);
                                            }
                                            }
                                            }